/*
 * State_Machine.h
 *
 *  Created on: Oct 2, 2024
 *      Author: Grasping
 */
#ifndef MY_INC_APP_APP_ACLOAD_GRIDSTATEMACHINE_H_
#define MY_INC_APP_APP_ACLOAD_GRIDSTATEMACHINE_H_
#include "MY_INC/APP/APP_ACLoad_Protection.h"
#include "MY_INC/APP/APP_ACLoad_Pwm.h"
#include "MY_INC/APP/APP_Init.h"
#include "MY_INC/LC/LC_SYS.h"
#include "stdbool.h"

static inline void RunGridLoop_State_ProcessControl(InterruptController *controller);
// static inline void RunGridLoop_State_Stop(InterruptController *controller);          // 停止状态处理
static inline void RunGridLoop_State_Idle(InterruptController *controller);          // 空闲状态处理
static inline void RunGridLoop_State_WaitLock(InterruptController *controller);      // 等待锁相状态处理
static inline void RunGridLoop_State_WaitCrossZero(InterruptController *controller); // 等待过零点状态处理
static inline void RunGridLoop_State_Running(InterruptController *controller);       // 运行状态处理
static inline void RunGridLoop_State_Machine(InterruptController *controller);       // 状态机主控函数

static inline void RunGridLoop_NoPLL_State_Machine(InterruptController *controller);
static inline void RunGridLoop_NoPLL_State_Stop(InterruptController *controller);
static inline void RunGridLoop_NoPLL_State_Idle(InterruptController *controller);
static inline void RunGridLoop_NoPLL_State_Running(InterruptController *controller);
static inline void RunGridLoop_NoPLL_State_WaitCrossZero(InterruptController *controller);

static inline void RunGridLoop_State_ProcessControl(InterruptController *Controller)
{
    RunGridLoop_State_Machine(Controller); // 运行无PLL状态机
    SPWM_Control_Inline(&Controller->pwm); // 传递整个 controller 和 PWM控制
}
static inline void RunGridLoop_State_Machine(InterruptController *controller)
{
    // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
    // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
    {
    case STATE_IDLE:
        RunGridLoop_State_Idle(controller); // 传递整个 controller
        break;
    case STATE_WAIT_LOCK:                       // 枚举名称从 STATE_WAITLOCK 改为 STATE_WAIT_LOCK
        RunGridLoop_State_WaitLock(controller); // 传递整个 controller
        break;
    case STATE_WAIT_CROSS_ZERO:                      // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
        RunGridLoop_State_WaitCrossZero(controller); // 传递整个 controller
        break;
    case STATE_RUN:                            // 枚举名称从 STATE_RUN 改为 STATE_RUN
        RunGridLoop_State_Running(controller); // 传递整个 controller
        break;
    default:
        break;
    }
}

// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
static inline void RunGridLoop_State_Idle(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE:                               // 无事件
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default: // 其他事件不响应
        break;
    }
}

/*---------- 等待状态处理 ----------*/
#define LOCK_TIMEOUT 20000 // 10ms超时（假设100us中断）
// 等待锁相状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)

static inline void RunGridLoop_State_WaitLock(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        // 访问 controller->param.lock_count
        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            if (controller->param.lock_count++ > 50) // 锁相计数器
            {
                controller->param.lock_timeout = 0;
                controller->param.lock_count = 0;                          // 锁相计数器清零
                controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
                break;
            }
        }
        else
        {
            controller->param.lock_count = 0; // 锁相计数器清零
        }
        controller->loop_sm.current_state = STATE_WAIT_LOCK; // 默认切换到等待锁相状态
        break;
    default: // 其他事件不响应
        break;
    }
}

static inline void RunGridLoop_State_WaitCrossZero(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
                          /*用户处理*/
        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            if (controller->param.pll->Theta < 2.0f / 360.0f * _2PI)
            {
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
                controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
                break;
            }
        }
        else
        {
            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
            break;
        }
        /*默认转移判断*/
        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

/*---------- 运行状态处理 ----------*/
// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunGridLoop_State_Running(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
                           &controller->param.pll->Sine, &controller->param.pll->Cosine);
        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
        /*状态转移判断*/
        if ((!_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) |
            (!_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            controller->pwm.pwm_en_flag = Nonactivated;          // 不允许PWM
            Loop_Init(&controller->param);                       // 初始化
            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
            break;
        }

        VariableStep_Update_Inline(controller->param.iref, controller->param.il_ref * _SQRT2 * 1.02f);
        controller->pwm.mod_wave = PMRdiff_Calculate_Inline(
            controller->param.pr_i, controller->param.iref->currentTemp * controller->param.pll->Sine,
            controller->param.il_actual);
        controller->pwm.pwm_en_flag = Activated; // 允许PWM

        /*默认转移*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    default: // 其他事件不响应
        break;
    }
}

static inline void RunGridLoop_NoPLL_State_Machine(InterruptController *controller)
{
    // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
    // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
    {
    case STATE_STOP:
        RunGridLoop_NoPLL_State_Stop(controller); // 传递整个 controller
        break;
    case STATE_IDLE:
        RunGridLoop_NoPLL_State_Idle(controller); // 传递整个 controller
        break;
    case STATE_WAIT_CROSS_ZERO:                            // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
        RunGridLoop_NoPLL_State_WaitCrossZero(controller); // 传递整个 controller
        break;
    case STATE_RUN:                                  // 枚举名称从 STATE_RUN 改为 STATE_RUN
        RunGridLoop_NoPLL_State_Running(controller); // 传递整个 controller
        break;
    default:                                            // 其他状态不处理
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

/*---------- 停止状态处理 ----------*/
// 参数类型修正，内部访问 loop_sm 和 param
static inline void RunGridLoop_NoPLL_State_Stop(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        Loop_Init(&controller->param);
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        Loop_Init(&controller->param);              // 初始化环路参数
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
static inline void RunGridLoop_NoPLL_State_Idle(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_ENABLE: // 环路开始事件
        /*用户处理*/
        /*状态切换条件*/
        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        /*状态切换条件*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

// 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunGridLoop_NoPLL_State_WaitCrossZero(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE:                                      // 无事件
                                                               /*用户处理*/
        if (controller->param.SignalAnalysisr_v->Vrms > 12.0f) // 有效值大于10V
        {
            if (controller->param.vo_actual < 0.5f)
            {
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
                // 这里需要设置PWM的初始状态，初始状态不对会炸机
                controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
                break;
            }
        }
        else // 有效值不满足
        {
            controller->loop_sm.current_state = STATE_STOP; // 返回
            break;
        }
        /*默认转移判断*/
        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

/*---------- 运行状态处理 ----------*/
// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunGridLoop_NoPLL_State_Running(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE:                                      // 无事件
                                                               /*用户处理*/
        if (controller->param.SignalAnalysisr_v->Vrms < 12.0f) // DQ范围规定
        {
            controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
            Loop_Init(&controller->param);                  // 初始化
            controller->loop_sm.current_state = STATE_STOP; // 返回空闲状态
            break;
        }
        VariableStep_Update_Inline(
            controller->param.iref,
            controller->param
                .il_ref); // 变步长还是有用的，优点：在你强制电流换向时提供过度点，防止变化过快炸机，缺点：会在启动时存在一个小的电流跌落

        float temp = controller->param.iref->currentTemp * controller->param.pll->Sine;
        controller->pwm.mod_wave =
            (PRdiff_Calculate_Inline(controller->param.pr_i[0], temp, controller->param.il_actual) +
             controller->param.vo_actual) /
            controller->param.trap_udc->notch.Yn; // 计算PWM调制波形  ,如果使用前馈记得把PR计算的1.0f限幅去掉
        controller->pwm.pwm_en_flag = Activated;  // 允许PWM
        /*默认转移*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
#endif /* INC_STATE_MACHINE_H_ */
